package Threadtest;

public class test7_deadlock {
    public static void main(String[] args) {
        deadlock d1 = new deadlock();
        deadlock d2 = new deadlock();

        d1.flag =1;
        d2.flag =0;
        Thread t1=new Thread(d1);
        Thread t2=new Thread(d2);

        t1.start();
        t2.start();
    }
}
class deadlock implements Runnable{
    static final Object obj1=new Object();
    static final Object obj2=new Object();
    public  int flag =1;
    @Override
    public void run() {
//        互斥条件：线程至少持有一个资源，并且在等待获取其他资源时不释放已持有的资源。
//
//        请求和保持条件：线程已经持有至少一个资源，并且在等待获取其他资源时保持对当前资源的持有。
//
//        不剥夺条件：资源只能由占有它的线程释放，不能被其他线程强行剥夺。
//
//        环路等待条件：一组线程，每个线程都在等待下一个线程所持有的资源，形成一个循环等待的情况。
      if (flag ==1){
          synchronized (obj1){
              System.out.println("obj1");
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  throw new RuntimeException(e);
              }
              synchronized (obj2){
                  System.out.println("obj2");
              }
          }
      }

        if (flag ==0){
            synchronized (obj2){
                System.out.println("obj1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (obj1){
                    System.out.println("obj2");
                }
            }
        }


    }
}
